home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Applications / Graphics / NXPlot3d / Source / lex.yy.c < prev    next >
Text File  |  1994-01-18  |  13KB  |  617 lines
  1. # include "stdio.h"
  2. # define U(x) x
  3. # define NLSTATE yyprevious=YYNEWLINE
  4. # define BEGIN yybgin = yysvec + 1 +
  5. # define INITIAL 0
  6. # define YYLERR yysvec
  7. # define YYSTATE (yyestate-yysvec-1)
  8. # define YYOPTIM 1
  9. # define YYLMAX 200
  10. # define output(c) putc(c,yyout)
  11. # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  12. # define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
  13. # define yymore() (yymorfg=1)
  14. # define ECHO fprintf(yyout, "%s",yytext)
  15. # define REJECT { nstr = yyreject(); goto yyfussy;}
  16. int yyleng; extern char yytext[];
  17. int yymorfg;
  18. extern char *yysptr, yysbuf[];
  19. int yytchar;
  20. FILE *yyin ={stdin}, *yyout ={stdout};
  21. extern int yylineno;
  22. struct yysvf { 
  23.     struct yywork *yystoff;
  24.     struct yysvf *yyother;
  25.     int *yystops;};
  26. struct yysvf *yyestate;
  27. extern struct yysvf yysvec[], *yybgin;
  28. /*
  29.     token.lm
  30.  
  31.     This file defines the tokens that the Expression grammar is built on.  To
  32.     fully understand this file, you will need to understand lex.  The basic
  33.     idea is that lex scans a text stream and breaks that stream up into tokens
  34.     which are then fed to the grammar (defined in yacc).  Whitespace is ignored
  35.     so the grammar is just fed a steady stream of significant tokens.
  36. */
  37.  
  38. /*
  39.  * These are the routines lex calls to get another character as it parses.
  40.  * By default they are macros which read from stdin. We toss the default
  41.  * macro definitions and supply our own versions of these, which will feed
  42.  * lex characters from the expression string we are parsing.
  43.  */
  44. #undef input
  45. #undef unput
  46. #undef output
  47. static int input();
  48. static void unput(char c);
  49. static void output(char c);
  50.  
  51. #import <stdlib.h>
  52. #import <string.h>
  53. #import <math.h>
  54. #import "exprDefs.h"
  55. #import "y.tab.h"
  56.  
  57. /* global which holds the string we are parsing */
  58. static const char *CurrText;
  59.  
  60. /* glue to get rid of compiler warnings */
  61. extern yylook(), yyback();
  62. static int yywrap();
  63. # define YYNEWLINE 10
  64. int yylex(){
  65. int nstr; extern int yyprevious;
  66. while((nstr = yylook()) >= 0)
  67. yyfussy: switch(nstr){
  68. case 0:
  69. if(yywrap()) return(0); break;
  70. case 1:
  71. {        /* whitespace - we ignore it */
  72.     ;
  73. }
  74. break;
  75. case 2:
  76. {        /* an integer */
  77.     yylval.integer = atoi(yytext);
  78.     return INTEGER;
  79. }
  80. break;
  81. case 3:
  82. {                   /* a float */
  83.     yylval.real = atof(yytext);
  84.     return NUMBER;
  85. }
  86. break;
  87. case 4:
  88. {    /* a radix number */
  89.     int radix;
  90.     register int mult = 1;
  91.     register char *c, *stop;
  92.     register unsigned int accum = 0;
  93.     register int charVal;
  94.  
  95.     sscanf( yytext, "%d#", &radix );
  96.     for( stop = yytext; *stop++ != '#'; ); /* skip the pound sign */
  97.     for( c = yytext+yyleng-1; c >= stop; c--, mult *= radix ) {
  98.         if( *c >= '0' && *c <= '9' )
  99.         charVal = *c - '0';
  100.         else if( *c >= 'A' && *c <= 'Z' )
  101.         charVal = *c - 'A' + 10;
  102.         else
  103.         charVal = *c - 'a' + 10;
  104.         accum += mult * charVal;
  105.     }
  106.     yylval.real = accum;
  107.     return NUMBER;
  108. }
  109. break;
  110. case 5:
  111. {            /* the constant pi */
  112.     yylval.real = M_PI;
  113.     return NUMBER;
  114. }
  115. break;
  116. case 6:
  117. {            /* the constant e */
  118.     yylval.real = M_E;
  119.     return NUMBER;
  120. }
  121. break;
  122. case 7:
  123.  {            /* a single char that must be recognized */
  124.     return yytext[0];
  125. }
  126. break;
  127. case 8:
  128. {    /* an identifier */
  129.     yylval.string = NXZoneMalloc(NXDefaultMallocZone(), yyleng+1); 
  130.     bcopy(yytext, yylval.string, yyleng);
  131.     yylval.string[yyleng] = '\0';
  132.     return IDENTIFIER;
  133. }
  134. break;
  135. case 9:
  136. {        /* other garbage chars (last rule is the default) */
  137.     yylval.character = yytext[0];
  138.     return BADCHAR;
  139. }
  140. break;
  141. case -1:
  142. break;
  143. default:
  144. fprintf(yyout,"bad switch yylook %d",nstr);
  145. } return(0); }
  146. /* end of yylex */
  147.  
  148. /* inits the global string to the one we will parse */
  149. void _EXPPrepareToScan(const char *text) {
  150.     CurrText = text;
  151. }
  152.  
  153. /* tells lex there's really no more input when we're done */
  154. static int yywrap() {
  155.     return 1;
  156. }
  157.  
  158. /* returns the next char of the string we're parsing */
  159. static int input() {
  160.     return *CurrText++;
  161. }
  162.  
  163. /* lets lex back up one char in the string we're parsing */
  164. static void unput(char c) {
  165.     --CurrText;
  166. }
  167.  
  168. /* called by lex when it wants to output a char.  This should never happen. */
  169. static void output(char c) {
  170.     fprintf(stderr, "lex output function called with char '%c'\n", c);
  171. }
  172. int yyvstop[] ={
  173. 0,
  174.  
  175. 9,
  176. 0,
  177.  
  178. 1,
  179. 9,
  180. 0,
  181.  
  182. 1,
  183. 0,
  184.  
  185. 7,
  186. 9,
  187. 0,
  188.  
  189. 7,
  190. 9,
  191. 0,
  192.  
  193. 9,
  194. 0,
  195.  
  196. 2,
  197. 9,
  198. 0,
  199.  
  200. 8,
  201. 9,
  202. 0,
  203.  
  204. 6,
  205. 8,
  206. 9,
  207. 0,
  208.  
  209. 8,
  210. 9,
  211. 0,
  212.  
  213. 3,
  214. 0,
  215.  
  216. 3,
  217. 0,
  218.  
  219. 2,
  220. 0,
  221.  
  222. 8,
  223. 0,
  224.  
  225. 5,
  226. 8,
  227. 0,
  228.  
  229. 4,
  230. 0,
  231.  
  232. 3,
  233. 0,
  234.  
  235. 3,
  236. 0,
  237.  
  238. 3,
  239. 0,
  240.  
  241. 3,
  242. 0,
  243.  
  244. 3,
  245. 0,
  246. 0};
  247. # define YYTYPE unsigned char
  248. struct yywork { YYTYPE verify, advance; } yycrank[] ={
  249. 0,0,    0,0,    1,3,    0,0,    
  250. 0,0,    0,0,    0,0,    0,0,    
  251. 0,0,    0,0,    1,4,    1,5,    
  252. 4,5,    4,5,    0,0,    0,0,    
  253. 0,0,    0,0,    0,0,    0,0,    
  254. 0,0,    0,0,    0,0,    0,0,    
  255. 0,0,    0,0,    0,0,    0,0,    
  256. 0,0,    0,0,    0,0,    0,0,    
  257. 0,0,    0,0,    0,0,    4,5,    
  258. 0,0,    0,0,    1,6,    0,0,    
  259. 0,0,    0,0,    0,0,    0,0,    
  260. 1,7,    0,0,    0,0,    1,8,    
  261. 2,8,    1,9,    7,13,    0,0,    
  262. 7,14,    7,14,    7,14,    7,14,    
  263. 7,14,    7,14,    7,14,    7,14,    
  264. 7,14,    7,14,    0,0,    0,0,    
  265. 0,0,    0,0,    1,10,    0,0,    
  266. 0,0,    0,0,    1,10,    8,15,    
  267. 8,15,    8,15,    8,15,    8,15,    
  268. 8,15,    8,15,    8,15,    8,15,    
  269. 8,15,    0,0,    0,0,    0,0,    
  270. 0,0,    0,0,    17,24,    17,24,    
  271. 17,24,    17,24,    17,24,    17,24,    
  272. 17,24,    17,24,    17,24,    17,24,    
  273. 1,10,    0,0,    0,0,    0,0,    
  274. 0,0,    0,0,    1,11,    2,11,    
  275. 9,16,    15,22,    0,0,    17,25,    
  276. 24,30,    0,0,    0,0,    0,0,    
  277. 0,0,    1,12,    2,12,    9,17,    
  278. 12,21,    9,18,    9,18,    9,18,    
  279. 9,18,    9,18,    9,18,    9,18,    
  280. 9,18,    9,18,    9,18,    10,20,    
  281. 10,20,    10,20,    10,20,    10,20,    
  282. 10,20,    10,20,    10,20,    10,20,    
  283. 10,20,    15,22,    9,19,    17,25,    
  284. 24,30,    0,0,    0,0,    0,0,    
  285. 10,20,    10,20,    10,20,    10,20,    
  286. 10,20,    10,20,    10,20,    10,20,    
  287. 10,20,    10,20,    10,20,    10,20,    
  288. 10,20,    10,20,    10,20,    10,20,    
  289. 10,20,    10,20,    10,20,    10,20,    
  290. 10,20,    10,20,    10,20,    10,20,    
  291. 10,20,    10,20,    9,19,    0,0,    
  292. 0,0,    0,0,    10,20,    0,0,    
  293. 10,20,    10,20,    10,20,    10,20,    
  294. 10,20,    10,20,    10,20,    10,20,    
  295. 10,20,    10,20,    10,20,    10,20,    
  296. 10,20,    10,20,    10,20,    10,20,    
  297. 10,20,    10,20,    10,20,    10,20,    
  298. 10,20,    10,20,    10,20,    10,20,    
  299. 10,20,    10,20,    16,23,    16,23,    
  300. 16,23,    16,23,    16,23,    16,23,    
  301. 16,23,    16,23,    16,23,    16,23,    
  302. 0,0,    0,0,    0,0,    0,0,    
  303. 0,0,    0,0,    0,0,    16,23,    
  304. 16,23,    16,23,    16,23,    16,23,    
  305. 16,23,    16,23,    16,23,    16,23,    
  306. 16,23,    16,23,    16,23,    16,23,    
  307. 16,23,    16,23,    16,23,    16,23,    
  308. 16,23,    16,23,    16,23,    16,23,    
  309. 16,23,    16,23,    16,23,    16,23,    
  310. 16,23,    0,0,    0,0,    0,0,    
  311. 0,0,    0,0,    0,0,    16,23,    
  312. 16,23,    16,23,    16,23,    16,23,    
  313. 16,23,    16,23,    16,23,    16,23,    
  314. 16,23,    16,23,    16,23,    16,23,    
  315. 16,23,    16,23,    16,23,    16,23,    
  316. 16,23,    16,23,    16,23,    16,23,    
  317. 16,23,    16,23,    16,23,    16,23,    
  318. 16,23,    19,26,    0,0,    19,26,    
  319. 0,0,    0,0,    19,27,    19,27,    
  320. 19,27,    19,27,    19,27,    19,27,    
  321. 19,27,    19,27,    19,27,    19,27,    
  322. 22,28,    0,0,    22,28,    0,0,    
  323. 0,0,    22,29,    22,29,    22,29,    
  324. 22,29,    22,29,    22,29,    22,29,    
  325. 22,29,    22,29,    22,29,    25,31,    
  326. 0,0,    25,31,    0,0,    0,0,    
  327. 25,32,    25,32,    25,32,    25,32,    
  328. 25,32,    25,32,    25,32,    25,32,    
  329. 25,32,    25,32,    26,27,    26,27,    
  330. 26,27,    26,27,    26,27,    26,27,    
  331. 26,27,    26,27,    26,27,    26,27,    
  332. 28,29,    28,29,    28,29,    28,29,    
  333. 28,29,    28,29,    28,29,    28,29,    
  334. 28,29,    28,29,    30,33,    0,0,    
  335. 30,33,    0,0,    0,0,    30,34,    
  336. 30,34,    30,34,    30,34,    30,34,    
  337. 30,34,    30,34,    30,34,    30,34,    
  338. 30,34,    31,32,    31,32,    31,32,    
  339. 31,32,    31,32,    31,32,    31,32,    
  340. 31,32,    31,32,    31,32,    33,34,    
  341. 33,34,    33,34,    33,34,    33,34,    
  342. 33,34,    33,34,    33,34,    33,34,    
  343. 33,34,    0,0,    0,0,    0,0,    
  344. 0,0};
  345. struct yysvf yysvec[] ={
  346. 0,    0,    0,
  347. yycrank+-1,    0,        0,    
  348. yycrank+-2,    yysvec+1,    0,    
  349. yycrank+0,    0,        yyvstop+1,
  350. yycrank+3,    0,        yyvstop+3,
  351. yycrank+0,    yysvec+4,    yyvstop+6,
  352. yycrank+0,    0,        yyvstop+8,
  353. yycrank+4,    0,        yyvstop+11,
  354. yycrank+23,    0,        yyvstop+14,
  355. yycrank+69,    0,        yyvstop+16,
  356. yycrank+79,    0,        yyvstop+19,
  357. yycrank+0,    yysvec+10,    yyvstop+22,
  358. yycrank+11,    yysvec+10,    yyvstop+26,
  359. yycrank+0,    yysvec+8,    0,    
  360. yycrank+0,    yysvec+7,    0,    
  361. yycrank+36,    yysvec+8,    yyvstop+29,
  362. yycrank+154,    0,        0,    
  363. yycrank+38,    0,        yyvstop+31,
  364. yycrank+0,    yysvec+9,    yyvstop+33,
  365. yycrank+234,    0,        0,    
  366. yycrank+0,    yysvec+10,    yyvstop+35,
  367. yycrank+0,    yysvec+10,    yyvstop+37,
  368. yycrank+249,    0,        0,    
  369. yycrank+0,    yysvec+16,    yyvstop+40,
  370. yycrank+39,    yysvec+17,    yyvstop+42,
  371. yycrank+264,    0,        0,    
  372. yycrank+274,    0,        0,    
  373. yycrank+0,    yysvec+26,    yyvstop+44,
  374. yycrank+284,    0,        0,    
  375. yycrank+0,    yysvec+28,    yyvstop+46,
  376. yycrank+299,    0,        0,    
  377. yycrank+309,    0,        0,    
  378. yycrank+0,    yysvec+31,    yyvstop+48,
  379. yycrank+319,    0,        0,    
  380. yycrank+0,    yysvec+33,    yyvstop+50,
  381. 0,    0,    0};
  382. struct yywork *yytop = yycrank+376;
  383. struct yysvf *yybgin = yysvec+1;
  384. char yymatch[] ={
  385. 00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  386. 01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
  387. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  388. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  389. 011 ,01  ,01  ,01  ,01  ,'%' ,01  ,01  ,
  390. '%' ,'%' ,'%' ,'+' ,'%' ,'+' ,01  ,'%' ,
  391. '0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
  392. '0' ,'0' ,01  ,01  ,01  ,01  ,01  ,01  ,
  393. 01  ,'A' ,'A' ,'A' ,'A' ,'E' ,'A' ,'A' ,
  394. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  395. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  396. 'A' ,'A' ,'A' ,01  ,01  ,01  ,'%' ,'_' ,
  397. 01  ,'A' ,'A' ,'A' ,'A' ,'E' ,'A' ,'A' ,
  398. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  399. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  400. 'A' ,'A' ,'A' ,01  ,01  ,01  ,01  ,01  ,
  401. 0};
  402. char yyextra[] ={
  403. 0,0,0,0,0,0,0,0,
  404. 0,0,0,0,0,0,0,0,
  405. 0};
  406. /*    ncform    4.1    83/08/11    */
  407.  
  408. int yylineno =1;
  409. # define YYU(x) x
  410. # define NLSTATE yyprevious=YYNEWLINE
  411. char yytext[YYLMAX];
  412. struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  413. char yysbuf[YYLMAX];
  414. char *yysptr = yysbuf;
  415. int *yyfnd;
  416. extern struct yysvf *yyestate;
  417. int yyprevious = YYNEWLINE;
  418. #if    NeXT
  419. int yylook(){
  420. #else
  421. yylook(){
  422. #endif    NeXT
  423.     register struct yysvf *yystate, **lsp;
  424.     register struct yywork *yyt;
  425.     struct yysvf *yyz;
  426.     int yych;
  427.     struct yywork *yyr;
  428. # ifdef LEXDEBUG
  429.     int debug;
  430. # endif
  431.     char *yylastch;
  432.     /* start off machines */
  433. # ifdef LEXDEBUG
  434.     debug = 0;
  435. # endif
  436.     if (!yymorfg)
  437.         yylastch = yytext;
  438.     else {
  439.         yymorfg=0;
  440.         yylastch = yytext+yyleng;
  441.         }
  442.     for(;;){
  443.         lsp = yylstate;
  444.         yyestate = yystate = yybgin;
  445.         if (yyprevious==YYNEWLINE) yystate++;
  446.         for (;;){
  447. # ifdef LEXDEBUG
  448.             if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
  449. # endif
  450.             yyt = yystate->yystoff;
  451.             if(yyt == yycrank){        /* may not be any transitions */
  452.                 yyz = yystate->yyother;
  453.                 if(yyz == 0)break;
  454.                 if(yyz->yystoff == yycrank)break;
  455.                 }
  456.             *yylastch++ = yych = input();
  457.         tryagain:
  458. # ifdef LEXDEBUG
  459.             if(debug){
  460.                 fprintf(yyout,"char ");
  461.                 allprint(yych);
  462.                 putchar('\n');
  463.                 }
  464. # endif
  465.             yyr = yyt;
  466.             if ( (int)yyt > (int)yycrank){
  467.                 yyt = yyr + yych;
  468.                 if (yyt <= yytop && yyt->verify+yysvec == yystate){
  469.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  470.                         {unput(*--yylastch);break;}
  471.                     *lsp++ = yystate = yyt->advance+yysvec;
  472.                     goto contin;
  473.                     }
  474.                 }
  475. # ifdef YYOPTIM
  476.             else if((int)yyt < (int)yycrank) {        /* r < yycrank */
  477.                 yyt = yyr = yycrank+(yycrank-yyt);
  478. # ifdef LEXDEBUG
  479.                 if(debug)fprintf(yyout,"compressed state\n");
  480. # endif
  481.                 yyt = yyt + yych;
  482.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  483.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  484.                         {unput(*--yylastch);break;}
  485.                     *lsp++ = yystate = yyt->advance+yysvec;
  486.                     goto contin;
  487.                     }
  488.                 yyt = yyr + YYU(yymatch[yych]);
  489. # ifdef LEXDEBUG
  490.                 if(debug){
  491.                     fprintf(yyout,"try fall back character ");
  492.                     allprint(YYU(yymatch[yych]));
  493.                     putchar('\n');
  494.                     }
  495. # endif
  496.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  497.                     if(yyt->advance+yysvec == YYLERR)    /* error transition */
  498.                         {unput(*--yylastch);break;}
  499.                     *lsp++ = yystate = yyt->advance+yysvec;
  500.                     goto contin;
  501.                     }
  502.                 }
  503.             if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
  504. # ifdef LEXDEBUG
  505.                 if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
  506. # endif
  507.                 goto tryagain;
  508.                 }
  509. # endif
  510.             else
  511.                 {unput(*--yylastch);break;}
  512.         contin:
  513. # ifdef LEXDEBUG
  514.             if(debug){
  515.                 fprintf(yyout,"state %d char ",yystate-yysvec-1);
  516.                 allprint(yych);
  517.                 putchar('\n');
  518.                 }
  519. # endif
  520.             ;
  521.             }
  522. # ifdef LEXDEBUG
  523.         if(debug){
  524.             fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
  525.             allprint(yych);
  526.             putchar('\n');
  527.             }
  528. # endif
  529.         while (lsp-- > yylstate){
  530.             *yylastch-- = 0;
  531.             if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
  532.                 yyolsp = lsp;
  533.                 if(yyextra[*yyfnd]){        /* must backup */
  534.                     while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
  535.                         lsp--;
  536.                         unput(*yylastch--);
  537.                         }
  538.                     }
  539.                 yyprevious = YYU(*yylastch);
  540.                 yylsp = lsp;
  541.                 yyleng = yylastch-yytext+1;
  542.                 yytext[yyleng] = 0;
  543. # ifdef LEXDEBUG
  544.                 if(debug){
  545.                     fprintf(yyout,"\nmatch ");
  546.                     sprint(yytext);
  547.                     fprintf(yyout," action %d\n",*yyfnd);
  548.                     }
  549. # endif
  550.                 return(*yyfnd++);
  551.                 }
  552.             unput(*yylastch);
  553.             }
  554.         if (yytext[0] == 0  /* && feof(yyin) */)
  555.             {
  556.             yysptr=yysbuf;
  557.             return(0);
  558.             }
  559.         yyprevious = yytext[0] = input();
  560.         if (yyprevious>0)
  561.             output(yyprevious);
  562.         yylastch=yytext;
  563. # ifdef LEXDEBUG
  564.         if(debug)putchar('\n');
  565. # endif
  566.         }
  567.     }
  568. #if    NeXT
  569. int yyback(p, m)
  570.     int *p;
  571.     int m;
  572. #else
  573. yyback(p, m)
  574.     int *p;
  575. #endif    NeXT
  576. {
  577. if (p==0) return(0);
  578. while (*p)
  579.     {
  580.     if (*p++ == m)
  581.         return(1);
  582.     }
  583. return(0);
  584. }
  585.     /* the following are only used in the lex library */
  586. #if    NeXT
  587. int yyinput(){
  588. #else
  589. yyinput(){
  590. #endif    NeXT
  591.     return(input());
  592.     }
  593. #if    NeXT
  594. void yyoutput(c)
  595.     int c; 
  596. {
  597.     output(c);
  598. }
  599. #else
  600. yyoutput(c)
  601.   int c; {
  602.     output(c);
  603.     }
  604. #endif    NeXT
  605. #if    NeXT
  606. void yyunput(c)
  607.     int c; 
  608. {
  609.     unput(c);
  610. }
  611. #else
  612. yyunput(c)
  613.    int c; {
  614.     unput(c);
  615.     }
  616. #endif    NeXT
  617.